# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

import minter.grpc.api_pb2 as api__pb2
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2

GRPC_GENERATED_VERSION = '1.65.4'
GRPC_VERSION = grpc.__version__
EXPECTED_ERROR_RELEASE = '1.66.0'
SCHEDULED_RELEASE_DATE = 'August 6, 2024'
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    warnings.warn(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in api_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
        + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},'
        + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.',
        RuntimeWarning
    )


class ApiServiceStub(object):
    """Missing associated documentation comment in .proto file."""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.Subscribe = channel.unary_stream(
                '/api_pb.ApiService/Subscribe',
                request_serializer=api__pb2.SubscribeRequest.SerializeToString,
                response_deserializer=api__pb2.SubscribeResponse.FromString,
                _registered_method=True)
        self.Halts = channel.unary_unary(
                '/api_pb.ApiService/Halts',
                request_serializer=api__pb2.HaltsRequest.SerializeToString,
                response_deserializer=api__pb2.HaltsResponse.FromString,
                _registered_method=True)
        self.Genesis = channel.unary_unary(
                '/api_pb.ApiService/Genesis',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=api__pb2.GenesisResponse.FromString,
                _registered_method=True)
        self.MinGasPrice = channel.unary_unary(
                '/api_pb.ApiService/MinGasPrice',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=api__pb2.MinGasPriceResponse.FromString,
                _registered_method=True)
        self.NetInfo = channel.unary_unary(
                '/api_pb.ApiService/NetInfo',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=api__pb2.NetInfoResponse.FromString,
                _registered_method=True)
        self.Status = channel.unary_unary(
                '/api_pb.ApiService/Status',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=api__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.Address = channel.unary_unary(
                '/api_pb.ApiService/Address',
                request_serializer=api__pb2.AddressRequest.SerializeToString,
                response_deserializer=api__pb2.AddressResponse.FromString,
                _registered_method=True)
        self.Addresses = channel.unary_unary(
                '/api_pb.ApiService/Addresses',
                request_serializer=api__pb2.AddressesRequest.SerializeToString,
                response_deserializer=api__pb2.AddressesResponse.FromString,
                _registered_method=True)
        self.Block = channel.unary_unary(
                '/api_pb.ApiService/Block',
                request_serializer=api__pb2.BlockRequest.SerializeToString,
                response_deserializer=api__pb2.BlockResponse.FromString,
                _registered_method=True)
        self.Candidate = channel.unary_unary(
                '/api_pb.ApiService/Candidate',
                request_serializer=api__pb2.CandidateRequest.SerializeToString,
                response_deserializer=api__pb2.CandidateResponse.FromString,
                _registered_method=True)
        self.Candidates = channel.unary_unary(
                '/api_pb.ApiService/Candidates',
                request_serializer=api__pb2.CandidatesRequest.SerializeToString,
                response_deserializer=api__pb2.CandidatesResponse.FromString,
                _registered_method=True)
        self.CoinInfoById = channel.unary_unary(
                '/api_pb.ApiService/CoinInfoById',
                request_serializer=api__pb2.CoinIdRequest.SerializeToString,
                response_deserializer=api__pb2.CoinInfoResponse.FromString,
                _registered_method=True)
        self.CoinInfo = channel.unary_unary(
                '/api_pb.ApiService/CoinInfo',
                request_serializer=api__pb2.CoinInfoRequest.SerializeToString,
                response_deserializer=api__pb2.CoinInfoResponse.FromString,
                _registered_method=True)
        self.EstimateCoinBuy = channel.unary_unary(
                '/api_pb.ApiService/EstimateCoinBuy',
                request_serializer=api__pb2.EstimateCoinBuyRequest.SerializeToString,
                response_deserializer=api__pb2.EstimateCoinBuyResponse.FromString,
                _registered_method=True)
        self.EstimateCoinSell = channel.unary_unary(
                '/api_pb.ApiService/EstimateCoinSell',
                request_serializer=api__pb2.EstimateCoinSellRequest.SerializeToString,
                response_deserializer=api__pb2.EstimateCoinSellResponse.FromString,
                _registered_method=True)
        self.EstimateCoinSellAll = channel.unary_unary(
                '/api_pb.ApiService/EstimateCoinSellAll',
                request_serializer=api__pb2.EstimateCoinSellAllRequest.SerializeToString,
                response_deserializer=api__pb2.EstimateCoinSellAllResponse.FromString,
                _registered_method=True)
        self.EstimateTxCommission = channel.unary_unary(
                '/api_pb.ApiService/EstimateTxCommission',
                request_serializer=api__pb2.EstimateTxCommissionRequest.SerializeToString,
                response_deserializer=api__pb2.EstimateTxCommissionResponse.FromString,
                _registered_method=True)
        self.Events = channel.unary_unary(
                '/api_pb.ApiService/Events',
                request_serializer=api__pb2.EventsRequest.SerializeToString,
                response_deserializer=api__pb2.EventsResponse.FromString,
                _registered_method=True)
        self.MaxGasPrice = channel.unary_unary(
                '/api_pb.ApiService/MaxGasPrice',
                request_serializer=api__pb2.MaxGasPriceRequest.SerializeToString,
                response_deserializer=api__pb2.MaxGasPriceResponse.FromString,
                _registered_method=True)
        self.MissedBlocks = channel.unary_unary(
                '/api_pb.ApiService/MissedBlocks',
                request_serializer=api__pb2.MissedBlocksRequest.SerializeToString,
                response_deserializer=api__pb2.MissedBlocksResponse.FromString,
                _registered_method=True)
        self.SendTransaction = channel.unary_unary(
                '/api_pb.ApiService/SendTransaction',
                request_serializer=api__pb2.SendTransactionRequest.SerializeToString,
                response_deserializer=api__pb2.SendTransactionResponse.FromString,
                _registered_method=True)
        self.Transaction = channel.unary_unary(
                '/api_pb.ApiService/Transaction',
                request_serializer=api__pb2.TransactionRequest.SerializeToString,
                response_deserializer=api__pb2.TransactionResponse.FromString,
                _registered_method=True)
        self.Transactions = channel.unary_unary(
                '/api_pb.ApiService/Transactions',
                request_serializer=api__pb2.TransactionsRequest.SerializeToString,
                response_deserializer=api__pb2.TransactionsResponse.FromString,
                _registered_method=True)
        self.UnconfirmedTxs = channel.unary_unary(
                '/api_pb.ApiService/UnconfirmedTxs',
                request_serializer=api__pb2.UnconfirmedTxsRequest.SerializeToString,
                response_deserializer=api__pb2.UnconfirmedTxsResponse.FromString,
                _registered_method=True)
        self.Validators = channel.unary_unary(
                '/api_pb.ApiService/Validators',
                request_serializer=api__pb2.ValidatorsRequest.SerializeToString,
                response_deserializer=api__pb2.ValidatorsResponse.FromString,
                _registered_method=True)
        self.Frozen = channel.unary_unary(
                '/api_pb.ApiService/Frozen',
                request_serializer=api__pb2.FrozenRequest.SerializeToString,
                response_deserializer=api__pb2.FrozenResponse.FromString,
                _registered_method=True)
        self.FrozenAll = channel.unary_unary(
                '/api_pb.ApiService/FrozenAll',
                request_serializer=api__pb2.FrozenAllRequest.SerializeToString,
                response_deserializer=api__pb2.FrozenResponse.FromString,
                _registered_method=True)
        self.WaitList = channel.unary_unary(
                '/api_pb.ApiService/WaitList',
                request_serializer=api__pb2.WaitListRequest.SerializeToString,
                response_deserializer=api__pb2.WaitListResponse.FromString,
                _registered_method=True)
        self.TestBlock = channel.unary_unary(
                '/api_pb.ApiService/TestBlock',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=api__pb2.BlockResponse.FromString,
                _registered_method=True)
        self.SwapPool = channel.unary_unary(
                '/api_pb.ApiService/SwapPool',
                request_serializer=api__pb2.SwapPoolRequest.SerializeToString,
                response_deserializer=api__pb2.SwapPoolResponse.FromString,
                _registered_method=True)
        self.SwapPools = channel.unary_unary(
                '/api_pb.ApiService/SwapPools',
                request_serializer=api__pb2.SwapPoolsRequest.SerializeToString,
                response_deserializer=api__pb2.SwapPoolsResponse.FromString,
                _registered_method=True)
        self.SwapPoolProvider = channel.unary_unary(
                '/api_pb.ApiService/SwapPoolProvider',
                request_serializer=api__pb2.SwapPoolProviderRequest.SerializeToString,
                response_deserializer=api__pb2.SwapPoolResponse.FromString,
                _registered_method=True)
        self.PriceCommission = channel.unary_unary(
                '/api_pb.ApiService/PriceCommission',
                request_serializer=api__pb2.PriceCommissionRequest.SerializeToString,
                response_deserializer=api__pb2.PriceCommissionResponse.FromString,
                _registered_method=True)
        self.VersionNetwork = channel.unary_unary(
                '/api_pb.ApiService/VersionNetwork',
                request_serializer=api__pb2.VersionNetworkRequest.SerializeToString,
                response_deserializer=api__pb2.VersionNetworkResponse.FromString,
                _registered_method=True)
        self.CommissionVotes = channel.unary_unary(
                '/api_pb.ApiService/CommissionVotes',
                request_serializer=api__pb2.CommissionVotesRequest.SerializeToString,
                response_deserializer=api__pb2.CommissionVotesResponse.FromString,
                _registered_method=True)
        self.UpdateVotes = channel.unary_unary(
                '/api_pb.ApiService/UpdateVotes',
                request_serializer=api__pb2.UpdateVotesRequest.SerializeToString,
                response_deserializer=api__pb2.UpdateVotesResponse.FromString,
                _registered_method=True)
        self.Blocks = channel.unary_unary(
                '/api_pb.ApiService/Blocks',
                request_serializer=api__pb2.BlocksRequest.SerializeToString,
                response_deserializer=api__pb2.BlocksResponse.FromString,
                _registered_method=True)
        self.LimitOrder = channel.unary_unary(
                '/api_pb.ApiService/LimitOrder',
                request_serializer=api__pb2.LimitOrderRequest.SerializeToString,
                response_deserializer=api__pb2.LimitOrderResponse.FromString,
                _registered_method=True)
        self.LimitOrdersOfPool = channel.unary_unary(
                '/api_pb.ApiService/LimitOrdersOfPool',
                request_serializer=api__pb2.LimitOrdersOfPoolRequest.SerializeToString,
                response_deserializer=api__pb2.LimitOrdersOfPoolResponse.FromString,
                _registered_method=True)
        self.LimitOrders = channel.unary_unary(
                '/api_pb.ApiService/LimitOrders',
                request_serializer=api__pb2.LimitOrdersRequest.SerializeToString,
                response_deserializer=api__pb2.LimitOrdersResponse.FromString,
                _registered_method=True)
        self.BestTrade = channel.unary_unary(
                '/api_pb.ApiService/BestTrade',
                request_serializer=api__pb2.BestTradeRequest.SerializeToString,
                response_deserializer=api__pb2.BestTradeResponse.FromString,
                _registered_method=True)


class ApiServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def Subscribe(self, request, context):
        """Subscribe returns a subscription for events by query. Only supported in WS and gRPC methods.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Halts(self, request, context):
        """Halts returns the candidate votes for stopping the network at block.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Genesis(self, request, context):
        """Genesis returns genesis file.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MinGasPrice(self, request, context):
        """MinGasPrice returns current min gas price.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NetInfo(self, request, context):
        """NetInfo returns network info
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Status(self, request, context):
        """Status returns node status including pubkey, latest block.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Address(self, request, context):
        """Address returns coins list, balance and transaction count of an address.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Addresses(self, request, context):
        """Addresses returns list of addresses.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Block(self, request, context):
        """Block returns block data at given height.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Candidate(self, request, context):
        """Candidate returns candidate’s info by provided public key.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Candidates(self, request, context):
        """Candidates returns list of candidates.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CoinInfoById(self, request, context):
        """CoinInfoById returns information about coin ID.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CoinInfo(self, request, context):
        """CoinInfo returns information about coin symbol.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EstimateCoinBuy(self, request, context):
        """EstimateCoinBuy returns estimate of buy coin transaction.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EstimateCoinSell(self, request, context):
        """EstimateCoinSell returns estimate of sell coin transaction.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EstimateCoinSellAll(self, request, context):
        """EstimateCoinSellAll returns estimate of sell all coin transaction.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EstimateTxCommission(self, request, context):
        """EstimateTxCommission returns estimate of transaction.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Events(self, request, context):
        """Events returns events at given height.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MaxGasPrice(self, request, context):
        """MaxGasPrice returns current max gas.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MissedBlocks(self, request, context):
        """MissedBlocks returns missed blocks by validator public key.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendTransaction(self, request, context):
        """SendTransaction returns the result of sending signed tx. To ensure that transaction was successfully committed to the blockchain, you need to find the transaction by the hash and ensure that the status code equals to 0.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Transaction(self, request, context):
        """Transaction returns transaction info.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Transactions(self, request, context):
        """Transactions returns transactions by query.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UnconfirmedTxs(self, request, context):
        """UnconfirmedTxs returns unconfirmed transactions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Validators(self, request, context):
        """Validators returns list of active validators.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Frozen(self, request, context):
        """Frozen returns frozen balance.
        Deprecated: Use FrozenAll instead.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FrozenAll(self, request, context):
        """FrozenAll returns frozen balance.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WaitList(self, request, context):
        """WaitList returns the list of address stakes in waitlist.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TestBlock(self, request, context):
        """TestBlock returns the list of example transactions in block. Available only testnet mode.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SwapPool(self, request, context):
        """SwapPool returns total supply and reserves.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SwapPools(self, request, context):
        """SwapPools returns list of all pools.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SwapPoolProvider(self, request, context):
        """SwapPoolProvider returns reserves and liquidity balance of provider.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PriceCommission(self, request, context):
        """PriceCommission returns commissions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def VersionNetwork(self, request, context):
        """VersionNetwork returns versions network.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CommissionVotes(self, request, context):
        """CommissionVotes returns votes for update commissions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateVotes(self, request, context):
        """UpdateVotes returns votes for update network.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Blocks(self, request, context):
        """Blocks returns blocks at given interval.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LimitOrder(self, request, context):
        """LimitOrder returns order by ID.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LimitOrdersOfPool(self, request, context):
        """LimitOrdersOfPool returns sell orders for a pair of coins.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LimitOrders(self, request, context):
        """LimitOrders returns orders by IDs.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def BestTrade(self, request, context):
        """BestTrade returns optimal exchange route.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ApiServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=api__pb2.SubscribeRequest.FromString,
                    response_serializer=api__pb2.SubscribeResponse.SerializeToString,
            ),
            'Halts': grpc.unary_unary_rpc_method_handler(
                    servicer.Halts,
                    request_deserializer=api__pb2.HaltsRequest.FromString,
                    response_serializer=api__pb2.HaltsResponse.SerializeToString,
            ),
            'Genesis': grpc.unary_unary_rpc_method_handler(
                    servicer.Genesis,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=api__pb2.GenesisResponse.SerializeToString,
            ),
            'MinGasPrice': grpc.unary_unary_rpc_method_handler(
                    servicer.MinGasPrice,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=api__pb2.MinGasPriceResponse.SerializeToString,
            ),
            'NetInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.NetInfo,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=api__pb2.NetInfoResponse.SerializeToString,
            ),
            'Status': grpc.unary_unary_rpc_method_handler(
                    servicer.Status,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=api__pb2.StatusResponse.SerializeToString,
            ),
            'Address': grpc.unary_unary_rpc_method_handler(
                    servicer.Address,
                    request_deserializer=api__pb2.AddressRequest.FromString,
                    response_serializer=api__pb2.AddressResponse.SerializeToString,
            ),
            'Addresses': grpc.unary_unary_rpc_method_handler(
                    servicer.Addresses,
                    request_deserializer=api__pb2.AddressesRequest.FromString,
                    response_serializer=api__pb2.AddressesResponse.SerializeToString,
            ),
            'Block': grpc.unary_unary_rpc_method_handler(
                    servicer.Block,
                    request_deserializer=api__pb2.BlockRequest.FromString,
                    response_serializer=api__pb2.BlockResponse.SerializeToString,
            ),
            'Candidate': grpc.unary_unary_rpc_method_handler(
                    servicer.Candidate,
                    request_deserializer=api__pb2.CandidateRequest.FromString,
                    response_serializer=api__pb2.CandidateResponse.SerializeToString,
            ),
            'Candidates': grpc.unary_unary_rpc_method_handler(
                    servicer.Candidates,
                    request_deserializer=api__pb2.CandidatesRequest.FromString,
                    response_serializer=api__pb2.CandidatesResponse.SerializeToString,
            ),
            'CoinInfoById': grpc.unary_unary_rpc_method_handler(
                    servicer.CoinInfoById,
                    request_deserializer=api__pb2.CoinIdRequest.FromString,
                    response_serializer=api__pb2.CoinInfoResponse.SerializeToString,
            ),
            'CoinInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.CoinInfo,
                    request_deserializer=api__pb2.CoinInfoRequest.FromString,
                    response_serializer=api__pb2.CoinInfoResponse.SerializeToString,
            ),
            'EstimateCoinBuy': grpc.unary_unary_rpc_method_handler(
                    servicer.EstimateCoinBuy,
                    request_deserializer=api__pb2.EstimateCoinBuyRequest.FromString,
                    response_serializer=api__pb2.EstimateCoinBuyResponse.SerializeToString,
            ),
            'EstimateCoinSell': grpc.unary_unary_rpc_method_handler(
                    servicer.EstimateCoinSell,
                    request_deserializer=api__pb2.EstimateCoinSellRequest.FromString,
                    response_serializer=api__pb2.EstimateCoinSellResponse.SerializeToString,
            ),
            'EstimateCoinSellAll': grpc.unary_unary_rpc_method_handler(
                    servicer.EstimateCoinSellAll,
                    request_deserializer=api__pb2.EstimateCoinSellAllRequest.FromString,
                    response_serializer=api__pb2.EstimateCoinSellAllResponse.SerializeToString,
            ),
            'EstimateTxCommission': grpc.unary_unary_rpc_method_handler(
                    servicer.EstimateTxCommission,
                    request_deserializer=api__pb2.EstimateTxCommissionRequest.FromString,
                    response_serializer=api__pb2.EstimateTxCommissionResponse.SerializeToString,
            ),
            'Events': grpc.unary_unary_rpc_method_handler(
                    servicer.Events,
                    request_deserializer=api__pb2.EventsRequest.FromString,
                    response_serializer=api__pb2.EventsResponse.SerializeToString,
            ),
            'MaxGasPrice': grpc.unary_unary_rpc_method_handler(
                    servicer.MaxGasPrice,
                    request_deserializer=api__pb2.MaxGasPriceRequest.FromString,
                    response_serializer=api__pb2.MaxGasPriceResponse.SerializeToString,
            ),
            'MissedBlocks': grpc.unary_unary_rpc_method_handler(
                    servicer.MissedBlocks,
                    request_deserializer=api__pb2.MissedBlocksRequest.FromString,
                    response_serializer=api__pb2.MissedBlocksResponse.SerializeToString,
            ),
            'SendTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.SendTransaction,
                    request_deserializer=api__pb2.SendTransactionRequest.FromString,
                    response_serializer=api__pb2.SendTransactionResponse.SerializeToString,
            ),
            'Transaction': grpc.unary_unary_rpc_method_handler(
                    servicer.Transaction,
                    request_deserializer=api__pb2.TransactionRequest.FromString,
                    response_serializer=api__pb2.TransactionResponse.SerializeToString,
            ),
            'Transactions': grpc.unary_unary_rpc_method_handler(
                    servicer.Transactions,
                    request_deserializer=api__pb2.TransactionsRequest.FromString,
                    response_serializer=api__pb2.TransactionsResponse.SerializeToString,
            ),
            'UnconfirmedTxs': grpc.unary_unary_rpc_method_handler(
                    servicer.UnconfirmedTxs,
                    request_deserializer=api__pb2.UnconfirmedTxsRequest.FromString,
                    response_serializer=api__pb2.UnconfirmedTxsResponse.SerializeToString,
            ),
            'Validators': grpc.unary_unary_rpc_method_handler(
                    servicer.Validators,
                    request_deserializer=api__pb2.ValidatorsRequest.FromString,
                    response_serializer=api__pb2.ValidatorsResponse.SerializeToString,
            ),
            'Frozen': grpc.unary_unary_rpc_method_handler(
                    servicer.Frozen,
                    request_deserializer=api__pb2.FrozenRequest.FromString,
                    response_serializer=api__pb2.FrozenResponse.SerializeToString,
            ),
            'FrozenAll': grpc.unary_unary_rpc_method_handler(
                    servicer.FrozenAll,
                    request_deserializer=api__pb2.FrozenAllRequest.FromString,
                    response_serializer=api__pb2.FrozenResponse.SerializeToString,
            ),
            'WaitList': grpc.unary_unary_rpc_method_handler(
                    servicer.WaitList,
                    request_deserializer=api__pb2.WaitListRequest.FromString,
                    response_serializer=api__pb2.WaitListResponse.SerializeToString,
            ),
            'TestBlock': grpc.unary_unary_rpc_method_handler(
                    servicer.TestBlock,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=api__pb2.BlockResponse.SerializeToString,
            ),
            'SwapPool': grpc.unary_unary_rpc_method_handler(
                    servicer.SwapPool,
                    request_deserializer=api__pb2.SwapPoolRequest.FromString,
                    response_serializer=api__pb2.SwapPoolResponse.SerializeToString,
            ),
            'SwapPools': grpc.unary_unary_rpc_method_handler(
                    servicer.SwapPools,
                    request_deserializer=api__pb2.SwapPoolsRequest.FromString,
                    response_serializer=api__pb2.SwapPoolsResponse.SerializeToString,
            ),
            'SwapPoolProvider': grpc.unary_unary_rpc_method_handler(
                    servicer.SwapPoolProvider,
                    request_deserializer=api__pb2.SwapPoolProviderRequest.FromString,
                    response_serializer=api__pb2.SwapPoolResponse.SerializeToString,
            ),
            'PriceCommission': grpc.unary_unary_rpc_method_handler(
                    servicer.PriceCommission,
                    request_deserializer=api__pb2.PriceCommissionRequest.FromString,
                    response_serializer=api__pb2.PriceCommissionResponse.SerializeToString,
            ),
            'VersionNetwork': grpc.unary_unary_rpc_method_handler(
                    servicer.VersionNetwork,
                    request_deserializer=api__pb2.VersionNetworkRequest.FromString,
                    response_serializer=api__pb2.VersionNetworkResponse.SerializeToString,
            ),
            'CommissionVotes': grpc.unary_unary_rpc_method_handler(
                    servicer.CommissionVotes,
                    request_deserializer=api__pb2.CommissionVotesRequest.FromString,
                    response_serializer=api__pb2.CommissionVotesResponse.SerializeToString,
            ),
            'UpdateVotes': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateVotes,
                    request_deserializer=api__pb2.UpdateVotesRequest.FromString,
                    response_serializer=api__pb2.UpdateVotesResponse.SerializeToString,
            ),
            'Blocks': grpc.unary_unary_rpc_method_handler(
                    servicer.Blocks,
                    request_deserializer=api__pb2.BlocksRequest.FromString,
                    response_serializer=api__pb2.BlocksResponse.SerializeToString,
            ),
            'LimitOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.LimitOrder,
                    request_deserializer=api__pb2.LimitOrderRequest.FromString,
                    response_serializer=api__pb2.LimitOrderResponse.SerializeToString,
            ),
            'LimitOrdersOfPool': grpc.unary_unary_rpc_method_handler(
                    servicer.LimitOrdersOfPool,
                    request_deserializer=api__pb2.LimitOrdersOfPoolRequest.FromString,
                    response_serializer=api__pb2.LimitOrdersOfPoolResponse.SerializeToString,
            ),
            'LimitOrders': grpc.unary_unary_rpc_method_handler(
                    servicer.LimitOrders,
                    request_deserializer=api__pb2.LimitOrdersRequest.FromString,
                    response_serializer=api__pb2.LimitOrdersResponse.SerializeToString,
            ),
            'BestTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.BestTrade,
                    request_deserializer=api__pb2.BestTradeRequest.FromString,
                    response_serializer=api__pb2.BestTradeResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'api_pb.ApiService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('api_pb.ApiService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class ApiService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def Subscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/api_pb.ApiService/Subscribe',
            api__pb2.SubscribeRequest.SerializeToString,
            api__pb2.SubscribeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Halts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Halts',
            api__pb2.HaltsRequest.SerializeToString,
            api__pb2.HaltsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Genesis(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Genesis',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            api__pb2.GenesisResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MinGasPrice(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/MinGasPrice',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            api__pb2.MinGasPriceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def NetInfo(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/NetInfo',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            api__pb2.NetInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Status(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Status',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            api__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Address(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Address',
            api__pb2.AddressRequest.SerializeToString,
            api__pb2.AddressResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Addresses(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Addresses',
            api__pb2.AddressesRequest.SerializeToString,
            api__pb2.AddressesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Block(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Block',
            api__pb2.BlockRequest.SerializeToString,
            api__pb2.BlockResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Candidate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Candidate',
            api__pb2.CandidateRequest.SerializeToString,
            api__pb2.CandidateResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Candidates(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Candidates',
            api__pb2.CandidatesRequest.SerializeToString,
            api__pb2.CandidatesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CoinInfoById(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/CoinInfoById',
            api__pb2.CoinIdRequest.SerializeToString,
            api__pb2.CoinInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CoinInfo(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/CoinInfo',
            api__pb2.CoinInfoRequest.SerializeToString,
            api__pb2.CoinInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EstimateCoinBuy(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/EstimateCoinBuy',
            api__pb2.EstimateCoinBuyRequest.SerializeToString,
            api__pb2.EstimateCoinBuyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EstimateCoinSell(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/EstimateCoinSell',
            api__pb2.EstimateCoinSellRequest.SerializeToString,
            api__pb2.EstimateCoinSellResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EstimateCoinSellAll(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/EstimateCoinSellAll',
            api__pb2.EstimateCoinSellAllRequest.SerializeToString,
            api__pb2.EstimateCoinSellAllResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EstimateTxCommission(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/EstimateTxCommission',
            api__pb2.EstimateTxCommissionRequest.SerializeToString,
            api__pb2.EstimateTxCommissionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Events(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Events',
            api__pb2.EventsRequest.SerializeToString,
            api__pb2.EventsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MaxGasPrice(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/MaxGasPrice',
            api__pb2.MaxGasPriceRequest.SerializeToString,
            api__pb2.MaxGasPriceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MissedBlocks(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/MissedBlocks',
            api__pb2.MissedBlocksRequest.SerializeToString,
            api__pb2.MissedBlocksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendTransaction(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/SendTransaction',
            api__pb2.SendTransactionRequest.SerializeToString,
            api__pb2.SendTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Transaction(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Transaction',
            api__pb2.TransactionRequest.SerializeToString,
            api__pb2.TransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Transactions(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Transactions',
            api__pb2.TransactionsRequest.SerializeToString,
            api__pb2.TransactionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnconfirmedTxs(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/UnconfirmedTxs',
            api__pb2.UnconfirmedTxsRequest.SerializeToString,
            api__pb2.UnconfirmedTxsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Validators(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Validators',
            api__pb2.ValidatorsRequest.SerializeToString,
            api__pb2.ValidatorsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Frozen(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Frozen',
            api__pb2.FrozenRequest.SerializeToString,
            api__pb2.FrozenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FrozenAll(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/FrozenAll',
            api__pb2.FrozenAllRequest.SerializeToString,
            api__pb2.FrozenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def WaitList(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/WaitList',
            api__pb2.WaitListRequest.SerializeToString,
            api__pb2.WaitListResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TestBlock(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/TestBlock',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            api__pb2.BlockResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SwapPool(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/SwapPool',
            api__pb2.SwapPoolRequest.SerializeToString,
            api__pb2.SwapPoolResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SwapPools(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/SwapPools',
            api__pb2.SwapPoolsRequest.SerializeToString,
            api__pb2.SwapPoolsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SwapPoolProvider(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/SwapPoolProvider',
            api__pb2.SwapPoolProviderRequest.SerializeToString,
            api__pb2.SwapPoolResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PriceCommission(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/PriceCommission',
            api__pb2.PriceCommissionRequest.SerializeToString,
            api__pb2.PriceCommissionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VersionNetwork(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/VersionNetwork',
            api__pb2.VersionNetworkRequest.SerializeToString,
            api__pb2.VersionNetworkResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CommissionVotes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/CommissionVotes',
            api__pb2.CommissionVotesRequest.SerializeToString,
            api__pb2.CommissionVotesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateVotes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/UpdateVotes',
            api__pb2.UpdateVotesRequest.SerializeToString,
            api__pb2.UpdateVotesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Blocks(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/Blocks',
            api__pb2.BlocksRequest.SerializeToString,
            api__pb2.BlocksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LimitOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/LimitOrder',
            api__pb2.LimitOrderRequest.SerializeToString,
            api__pb2.LimitOrderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LimitOrdersOfPool(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/LimitOrdersOfPool',
            api__pb2.LimitOrdersOfPoolRequest.SerializeToString,
            api__pb2.LimitOrdersOfPoolResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LimitOrders(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/LimitOrders',
            api__pb2.LimitOrdersRequest.SerializeToString,
            api__pb2.LimitOrdersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def BestTrade(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/api_pb.ApiService/BestTrade',
            api__pb2.BestTradeRequest.SerializeToString,
            api__pb2.BestTradeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
